home *** CD-ROM | disk | FTP | other *** search
/ Sprite 1984 - 1993 / Sprite 1984 - 1993.iso / src / cmds / lfsrebuild / diff < prev    next >
Encoding:
Text File  |  1992-03-12  |  13.6 KB  |  494 lines
  1. 17c17
  2. < static char rcsid[] = "$Header: /sprite/src/cmds/fscheck/RCS/checkdir.c,v 1.29 90/10/10 15:29:03 mendel Exp $ SPRITE (Berkeley)";
  3. ---
  4. > static char rcsid[] = "$Header: /sprite/src/cmds/fscheck/RCS/checkdir.c,v 1.30 90/11/01 23:28:33 jhh Exp $ SPRITE (Berkeley)";
  5. 20c20
  6. < #include <option.h>
  7. ---
  8. > #include "option.h"
  9. 22c22
  10. < #include <list.h>
  11. ---
  12. > #include "list.h"
  13. 27c27,28
  14. < static  int         lostFoundFileNum = -1;
  15. ---
  16. > static    int        adding = 0;
  17. > extern    int         writeDisk;
  18. 28a30,43
  19. > static    FdInfo        *descInfoArray;
  20. > static    int    
  21. > lostFoundFileNum = -1;
  22. > extern    int        patchRoot;
  23. > int            outputFileNum = -1;
  24. > int            partFID;
  25. > Ofs_DomainHeader        *domainPtr;
  26. > 
  27. > void            CheckDirEntry();
  28. > static void        CheckDir();
  29. > static ReturnStatus    AddToDirectory();
  30. > 
  31. > Fsdm_FileDescriptor    *rootFDPtr;
  32. > Fsdm_FileDescriptor    *lostFoundFDPtr;
  33. 30,44c45
  34. < int foundError;
  35. < int verbose = 1;
  36. < int debug = 0;
  37. < int tooBig = 0;
  38. < static int        diskFd;
  39. < 
  40. < Fsdm_FileDescriptor    *rootFDPtr, *lostFoundFDPtr;
  41. < 
  42. < static int MakePtrAccessible _ARGS_((register DirIndexInfo *indexInfoPtr));
  43. < static int GetFirstIndex _ARGS_((int blockNum, register DirIndexInfo *indexInfoPtr));
  44. < static int GetNextIndex _ARGS_((register DirIndexInfo *indexInfoPtr));
  45. < static void OpenDir _ARGS_((Fsdm_FileDescriptor *fdPtr, FdInfo *fdInfoPtr, DirIndexInfo *indexInfoPtr, Fslcl_DirEntry **dirEntryPtrPtr));
  46. < static void NextDirEntry _ARGS_((DirIndexInfo *indexInfoPtr, Fslcl_DirEntry **dirEntryPtrPtr));
  47. < static void CloseDir _ARGS_((DirIndexInfo *indexInfoPtr));
  48. < static void CheckDir _ARGS_((int fdNum, Fsdm_FileDescriptor *fdPtr, FdInfo *fdInfoPtr, int parentFdNum, int lostDirNum, int *dirOKPtr));
  49. ---
  50. > extern int verbose;
  51. 70,73c71,75
  52. <     int bufSize,  j;
  53. <     LfsFileDescriptor    *descPtr;
  54. <     char *descBuf;
  55. <     LfsDescMapEntry *descMapPtr;
  56. ---
  57. >     ModListElement    *modElemPtr;
  58. >     RelocListElement    *relocElemPtr;
  59. >     static char        block[FS_BLOCK_SIZE];
  60. >     int            blockNum;
  61. >     int            offset;
  62. 75,83c77
  63. <     if ((fdNum < 0) || (fdNum >= superBlockPtr->descMap.maxDesc)) {
  64. <     return 0;
  65. <     }
  66. <     if (descInfoArray[fdNum].flags & FD_UNREADABLE) {
  67. <     return 0;
  68. <     }
  69. <     bufSize = superBlockPtr->fileLayout.descPerBlock * sizeof(*descPtr);
  70. < 
  71. <     descBuf = alloca(bufSize);
  72. ---
  73. >     descInfoArray[fdNum].flags &= ~FD_MODIFIED;
  74. 85,106c79,80
  75. <     descMapPtr = DescMapEntry(fdNum);
  76. <     if (descMapPtr->flags != LFS_DESC_MAP_ALLOCED) {
  77. <     Alloc(*fdPtrPtr,Fsdm_FileDescriptor,1);
  78. <     if (tooBig) {
  79. <         return 0;
  80. <     }
  81. <     bzero((char *) *fdPtrPtr, sizeof(Fsdm_FileDescriptor));
  82. <     return 1;
  83. <     }
  84. <     if (DiskRead(diskFd, descMapPtr->blockAddress, bufSize, descBuf)
  85. <             != bufSize) {
  86. <     return 0;
  87. <     }
  88. <     descPtr = (LfsFileDescriptor *)descBuf;
  89. <     for (j = 0; j < superBlockPtr->fileLayout.descPerBlock; j++) {
  90. <     if (!(descPtr->common.flags & FSDM_FD_ALLOC)) {
  91. <         break;
  92. <     }
  93. <     if (descPtr->fileNumber == fdNum) {
  94. <         break;
  95. <     }
  96. <     descPtr++;
  97. ---
  98. >     if (descInfoArray[fdNum].flags & FD_UNREADABLE) {
  99. >     return(0);
  100. 108,111c82,107
  101. <     if ((j >= superBlockPtr->fileLayout.descPerBlock) ||
  102. <     !(descPtr->common.flags & FSDM_FD_ALLOC) ||
  103. <     (descPtr->fileNumber != fdNum)) {
  104. <     return 0;
  105. ---
  106. >     if (descInfoArray[fdNum].flags & FD_RELOCATE) {
  107. >     LIST_FORALL(relocList, (List_Links *)relocElemPtr) {
  108. >         if (relocElemPtr->origFdNum == fdNum) {
  109. >         *fdPtrPtr = relocElemPtr->fdPtr;
  110. >         return(1);
  111. >         }
  112. >     }
  113. >     Output(stderr, "FetchFileDesc: FD not found in relocate list.\n");
  114. >     abort();
  115. >     }
  116. >     if (descInfoArray[fdNum].flags & ON_MOD_LIST) {
  117. >     LIST_FORALL(modList, (List_Links *)modElemPtr) {
  118. >         if (modElemPtr->fdNum == fdNum) {
  119. >         *fdPtrPtr = modElemPtr->fdPtr;
  120. >         return(1);
  121. >         }
  122. >     }
  123. >     Output(stderr, "FetchFileDesc: FD not found in mod list.\n");
  124. >     abort();
  125. >     }
  126. >     blockNum = domainPtr->fileDescOffset + fdNum / FSDM_FILE_DESC_PER_BLOCK;
  127. >     offset = (fdNum & (FSDM_FILE_DESC_PER_BLOCK - 1)) * FSDM_MAX_FILE_DESC_SIZE;
  128. >     if (Disk_BlockRead(partFID, domainPtr, blockNum, 1, 
  129. >                (Address) block) < 0) {
  130. >     OutputPerror("FetchFileDesc: Read failed on previously readable block");
  131. >     exit(EXIT_READ_FAILURE);
  132. 117c113
  133. <     bcopy((Address)&(descPtr->common), (Address)*fdPtrPtr, 
  134. ---
  135. >     bcopy((Address)&block[offset], (Address)*fdPtrPtr, 
  136. 143,144c139,167
  137. <     extern void panic();
  138. <     panic("StoreFileDesc not implemented\n");
  139. ---
  140. >     ModListElement    *modElemPtr;
  141. > 
  142. >     if (descInfoArray[fdNum].flags & FD_MODIFIED) {
  143. >     if (descInfoArray[fdNum].flags & ON_MOD_LIST) {
  144. >         LIST_FORALL(modList, (List_Links *)modElemPtr) {
  145. >         if (modElemPtr->fdNum == fdNum) {
  146. >             /*
  147. >              * The old fd may be in use on another list so we can't
  148. >              * free it, but it may become unreferenced. 
  149. >              */
  150. >             modElemPtr->fdPtr = fdPtr;
  151. >             return;
  152. >         }
  153. >         }
  154. >         Output(stderr, "StoreFileDesc: FD not found in list.\n");
  155. >         abort();
  156. >     } else {
  157. >         ModListElement    *modElemPtr;
  158. > 
  159. >         Alloc(modElemPtr,ModListElement,1);
  160. >         if (tooBig) {
  161. >         return;
  162. >         }
  163. >         descInfoArray[fdNum].flags |= ON_MOD_LIST;
  164. >         modElemPtr->fdNum = fdNum;
  165. >         modElemPtr->fdPtr = fdPtr;
  166. >         List_Insert((List_Links *)modElemPtr, LIST_ATREAR(modList));
  167. >     }
  168. >     }
  169. 186,189c209,212
  170. <     if (DiskRead(diskFd,
  171. <               *blockAddrPtr, FS_BLOCK_SIZE,
  172. <               indexInfoPtr->firstBlock) != FS_BLOCK_SIZE) {
  173. <         fprintf(stderr,"MakePtrAccessible: Read (1) failed block %d\n",
  174. ---
  175. >     if (Disk_FragRead(partFID, domainPtr,
  176. >               *blockAddrPtr, FS_FRAGMENTS_PER_BLOCK,
  177. >               indexInfoPtr->firstBlock) < 0) {
  178. >         Output(stderr,"MakePtrAccessible: Read (1) failed block %d\n",
  179. 206,209c229,232
  180. <     if (DiskRead(diskFd, 
  181. <               *blockAddrPtr, FS_BLOCK_SIZE,
  182. <               indexInfoPtr->secondBlock) != FS_BLOCK_SIZE) {
  183. <         fprintf(stderr,"MakePtrAccessible: Read (2) failed block %d\n",
  184. ---
  185. >     if (Disk_FragRead(partFID, domainPtr,
  186. >               *blockAddrPtr, FS_FRAGMENTS_PER_BLOCK,
  187. >               indexInfoPtr->secondBlock) < 0) {
  188. >         Output(stderr,"MakePtrAccessible: Read (2) failed block %d\n",
  189. 406c429
  190. < static void
  191. ---
  192. > void
  193. 425c448
  194. <     fprintf(stderr,
  195. ---
  196. >     Output(stderr,
  197. 438c461
  198. <     fprintf(stderr, "OpenDir: Error setting up index\n");
  199. ---
  200. >     Output(stderr, "OpenDir: Error setting up index\n");
  201. 451,456c474,480
  202. <     if (DiskRead(diskFd, 
  203. <               indexInfoPtr->blockAddr, 
  204. <               fragsToRead*FS_FRAGMENT_SIZE, indexInfoPtr->dirBlock) 
  205. <               != fragsToRead*FS_FRAGMENT_SIZE) {
  206. <     fprintf(stderr, "OpenDir: Read failed block %d\n",
  207. <                indexInfoPtr->blockAddr); 
  208. ---
  209. >     if (Disk_FragRead(partFID, domainPtr,
  210. >               indexInfoPtr->blockAddr + 
  211. >               domainPtr->dataOffset * FS_FRAGMENTS_PER_BLOCK, 
  212. >               fragsToRead, indexInfoPtr->dirBlock) < 0) {
  213. >     Output(stderr, "OpenDir: Read failed block %d\n",
  214. >                indexInfoPtr->blockAddr + 
  215. >                        domainPtr->dataOffset * FS_FRAGMENTS_PER_BLOCK);
  216. 481c505
  217. < static void
  218. ---
  219. > void
  220. 501a526,537
  221. >     if (indexInfoPtr->dirDirty && writeDisk) {
  222. >         if (Disk_FragWrite(partFID, domainPtr,
  223. >                   indexInfoPtr->blockAddr + 
  224. >                   domainPtr->dataOffset * 
  225. >                   FS_FRAGMENTS_PER_BLOCK, 
  226. >                   indexInfoPtr->numFrags, 
  227. >                   indexInfoPtr->dirBlock) < 0) {
  228. >         Output(stderr, "NextDirEntry: Write failed block %d\n",
  229. >                    indexInfoPtr->blockAddr + 
  230. >                     domainPtr->dataOffset * FS_FRAGMENTS_PER_BLOCK);
  231. >         }
  232. >     }
  233. 516d551
  234. < #ifdef notdef
  235. 517a553,561
  236. >         if (Disk_FragWrite(partFID, domainPtr,
  237. >                   indexInfoPtr->blockAddr + 
  238. >                   domainPtr->dataOffset * 
  239. >                   FS_FRAGMENTS_PER_BLOCK, 
  240. >                   indexInfoPtr->numFrags, 
  241. >                   indexInfoPtr->dirBlock) < 0) {
  242. >         Output(stderr, "NextDirEntry: Write (2) failed block %d\n",
  243. >                    indexInfoPtr->blockAddr + 
  244. >                     domainPtr->dataOffset * FS_FRAGMENTS_PER_BLOCK);
  245. 518a563
  246. >         return;
  247. 521d565
  248. < #endif
  249. 523c567
  250. <         fprintf(stderr, "NextDirEntry: Get index failed\n");
  251. ---
  252. >         Output(stderr, "NextDirEntry: Get index failed\n");
  253. 534,538c578,585
  254. <     if (DiskRead(diskFd,   indexInfoPtr->blockAddr,
  255. <               fragsToRead*FS_FRAGMENT_SIZE, 
  256. <               indexInfoPtr->dirBlock) != fragsToRead*FS_FRAGMENT_SIZE) {
  257. <         fprintf(stderr, "NextDirEntry: Read failed block %d\n",
  258. <                 indexInfoPtr->blockAddr); 
  259. ---
  260. >     if (Disk_FragRead(partFID, domainPtr,
  261. >               indexInfoPtr->blockAddr + 
  262. >               domainPtr->dataOffset * 
  263. >               FS_FRAGMENTS_PER_BLOCK, 
  264. >               fragsToRead, indexInfoPtr->dirBlock) < 0) {
  265. >         Output(stderr, "NextDirEntry: Read failed block %d\n",
  266. >                 indexInfoPtr->blockAddr + 
  267. >                 domainPtr->dataOffset * FS_FRAGMENTS_PER_BLOCK);
  268. 551a599,600
  269. > static    DirIndexInfo    rootDirIndex;
  270. > static  Fslcl_DirEntry    *rootDirEntryPtr;
  271. 580d628
  272. < #ifdef notdef
  273. 581a630,638
  274. >     if (Disk_FragWrite(partFID, domainPtr,
  275. >               indexInfoPtr->blockAddr + 
  276. >               domainPtr->dataOffset * 
  277. >               FS_FRAGMENTS_PER_BLOCK, 
  278. >               indexInfoPtr->numFrags, 
  279. >               indexInfoPtr->dirBlock) < 0) {
  280. >         Output(stderr, "CloseDir: Write (2) failed block %d\n",
  281. >                indexInfoPtr->blockAddr + 
  282. >                 domainPtr->dataOffset * FS_FRAGMENTS_PER_BLOCK);
  283. 582a640
  284. >     }
  285. 584d641
  286. < #endif
  287. 605,606c662,667
  288. < CheckDirTree(diskId)
  289. <     int            diskId;
  290. ---
  291. > CheckDirTree(partFIDParm, domainParmPtr, descInfoParm,fdBitmapPtr, bitmapPtr)
  292. >     int            partFIDParm;
  293. >     Ofs_DomainHeader    *domainParmPtr;
  294. >     FdInfo        *descInfoParm;
  295. >     u_char        *fdBitmapPtr;
  296. >     u_char        *bitmapPtr;
  297. 615a677,679
  298. >     char        newFileName[100];
  299. >     int            offset;
  300. >     int            outputFileLength;
  301. 617a682,684
  302. >     partFID = partFIDParm;
  303. >     domainPtr = domainParmPtr;
  304. >     descInfoArray = descInfoParm;
  305. 619d685
  306. <     diskFd = diskId;
  307. 624c690
  308. <     fprintf(stderr, "Unable to fetch file descriptor for root");
  309. ---
  310. >     Output(stderr, "Unable to fetch file descriptor for root");
  311. 631a698
  312. >     char *fileName;
  313. 633c700
  314. <     fprintf(stderr, "Root directory corrupted\n");
  315. ---
  316. >     Output(stderr, "Root directory corrupted\n");
  317. 636a704,709
  318. >     /*
  319. >      * On 5/10/88 the root of a disk (/sprite) was overwritten.  It was
  320. >      * patched by looking for directories with a ".." entry that
  321. >      * referenced root, fileNumber == 2, and putting them into the
  322. >      * root just like other orphans are put into lost+found.
  323. >      */
  324. 694a768,770
  325. >     if (outputFileName != NULL) {
  326. >     outputFileLength = strlen(outputFileName);
  327. >     }
  328. 703a780,784
  329. >     } else if (rawOutput && outputFileName != NULL &&
  330. >         (dirEntryPtr->nameLength == outputFileLength) && 
  331. >         strncmp(outputFileName, dirEntryPtr->fileName, outputFileLength)
  332. >         == 0) {
  333. >         outputFileNum = dirEntryPtr->fileNumber;
  334. 714c795
  335. <     fprintf(stderr, "lost+found missing from root\n");
  336. ---
  337. >     Output(stderr, "lost+found missing from root\n");
  338. 721c802
  339. <         fprintf(stderr, "Unable to fetch file descriptor for lost+found");
  340. ---
  341. >         Output(stderr, "Unable to fetch file descriptor for lost+found");
  342. 728c809
  343. <         fprintf(stderr,
  344. ---
  345. >         Output(stderr,
  346. 740c821
  347. <             fprintf(stderr, "Could not open lost+found\n");
  348. ---
  349. >             Output(stderr, "Could not open lost+found\n");
  350. 750d830
  351. < 
  352. 753a834
  353. > 
  354. 759c840
  355. <      i < superBlockPtr->descMap.maxDesc; 
  356. ---
  357. >      i < domainPtr->numFileDesc; 
  358. 771c852
  359. <         fprintf(stderr,
  360. ---
  361. >         Output(stderr,
  362. 778a860
  363. > 
  364. 832c914
  365. <      i < superBlockPtr->descMap.maxDesc; 
  366. ---
  367. >      i <= domainPtr->numFileDesc; 
  368. 839d920
  369. < 
  370. 842c923
  371. <     } else if (i == superBlockPtr->descMap.maxDesc-1) {
  372. ---
  373. >     } else if (i == domainPtr->numFileDesc) {
  374. 857c938
  375. <         fprintf(stderr, "File %d is unreferenced\n", i);
  376. ---
  377. >         Output(stderr, "File %d is unreferenced\n", i);
  378. 864d944
  379. < 
  380. 869c949
  381. <             fprintf(stderr, 
  382. ---
  383. >             Output(stderr, 
  384. 878c958
  385. <         fprintf(stderr,
  386. ---
  387. >         Output(stderr,
  388. 894c974
  389. <             fprintf(stderr,
  390. ---
  391. >             Output(stderr,
  392. 908c988
  393. <     fprintf(stderr, "%d files not added to directory %d.\n", notAdded,
  394. ---
  395. >     Output(stderr, "%d files not added to directory %d.\n", notAdded,
  396. 913c993
  397. <     fprintf(stderr, "%d unreferenced files\n", unrefFiles);
  398. ---
  399. >     Output(stderr, "%d unreferenced files\n", unrefFiles);
  400. 916c996
  401. <     fprintf(stderr, "%d links counts corrected\n",
  402. ---
  403. >     Output(stderr, "%d links counts corrected\n",
  404. 920d999
  405. < #ifdef notdef
  406. 931d1009
  407. < #endif
  408. 965d1042
  409. <                      */
  410. 988c1065
  411. <     fprintf(stderr, "Empty directory %d %s changed to a file.\n",
  412. ---
  413. >     Output(stderr, "Empty directory %d %s changed to a file.\n",
  414. 1000c1077
  415. <     fprintf(stderr,"Working on %s\n",pathName);
  416. ---
  417. >     Output(stderr,"Working on %s\n",pathName);
  418. 1012c1089
  419. <         fprintf(stderr,
  420. ---
  421. >         Output(stderr,
  422. 1022c1099
  423. <         fprintf(stderr, 
  424. ---
  425. >         Output(stderr, 
  426. 1037c1114
  427. <         fprintf(stderr,
  428. ---
  429. >         Output(stderr,
  430. 1047c1124
  431. <         fprintf(stderr, 
  432. ---
  433. >         Output(stderr, 
  434. 1065c1142
  435. <             fprintf(stderr, "Found #%d, an orphan of dir #%d\n", 
  436. ---
  437. >             Output(stderr, "Found #%d, an orphan of dir #%d\n", 
  438. 1091c1168
  439. <             fprintf(stderr,
  440. ---
  441. >             Output(stderr,
  442. 1158c1235
  443. <     fprintf(stderr,
  444. ---
  445. >     Output(stderr,
  446. 1182c1259
  447. <         fprintf(stderr,
  448. ---
  449. >         Output(stderr,
  450. 1204c1281
  451. <         fprintf(stderr,
  452. ---
  453. >         Output(stderr,
  454. 1216,1217c1293,1294
  455. <         dirEntryPtr->fileNumber >= superBlockPtr->descMap.maxDesc) {
  456. <     fprintf(stderr, 
  457. ---
  458. >         dirEntryPtr->fileNumber >= domainPtr->numFileDesc) {
  459. >     Output(stderr, 
  460. 1233c1310
  461. <     fprintf(stderr, 
  462. ---
  463. >     Output(stderr, 
  464. 1242c1319
  465. <     fprintf(stderr,"Entry %s ok.\n",dirEntryPtr->fileName);
  466. ---
  467. >     Output(stderr,"Entry %s ok.\n",dirEntryPtr->fileName);
  468. 1245c1322
  469. <     fprintf(stderr,
  470. ---
  471. >     Output(stderr,
  472. 1251d1327
  473. < #ifdef notdef
  474. 1284c1360
  475. <     fprintf(stderr, "SetDotDot: Could not open dir\n");
  476. ---
  477. >     Output(stderr, "SetDotDot: Could not open dir\n");
  478. 1293c1369
  479. <     fprintf(stderr, "SetDotDot: Could not move from . to ..\n");
  480. ---
  481. >     Output(stderr, "SetDotDot: Could not move from . to ..\n");
  482. 1304c1380
  483. <         fprintf(stderr, "SetDotDot: Write failed block %d\n",
  484. ---
  485. >         Output(stderr, "SetDotDot: Write failed block %d\n",
  486. 1311a1388
  487. > 
  488. 1371c1448
  489. <         fprintf(stderr,
  490. ---
  491. >         Output(stderr,
  492. 1474d1550
  493. < #endif
  494.